package it.okkam.utility;

import it.okkam.Changes.EventoCambiamento;
import it.okkam.strutturedati.AttributiParticella;
import it.okkam.strutturedati.ConfineComune;
import it.okkam.strutturedati.Particella;
import it.okkam.strutturedati.ParticellaCatastale;
import it.okkam.strutturedati.Poligono;
import it.okkam.strutturedati.Punto;
import it.okkam.strutturedati.Vertice;

import java.io.File;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.StringTokenizer;

import javax.annotation.Resource;

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.vocabulary.RDF;

public class Utility {

	/**
	 * converte la coordinata in formato testuale in formato numerico la
	 * coordinata testuale deve essere del tipo 0.2221223E06
	 * 
	 * @param coordinata
	 *            in formato testuale
	 * @return coordinata in formato numerico
	 */
	public double convertiTestoToNumero(String coordinataTestuale) {

		double coordinata = 0;
		int potenza;
		String radice, segno, potenzaStringa;
		if (coordinataTestuale != null) {
			// estraggo la radice della coordinata
			int indice = coordinataTestuale.indexOf('E');
			radice = coordinataTestuale.substring(0, indice);
			coordinata = Double.parseDouble(radice);
			// estraggo il segno della potenza
			segno = coordinataTestuale.substring((indice + 1), (indice + 2));
			// estraggo l'esponente
			potenzaStringa = coordinataTestuale.substring(indice + 2);
			potenza = Integer.parseInt(potenzaStringa);
			// adegue l'esponente al segno
			if (segno.equals("-"))
				potenza = potenza * (-1);
			// calcolo la coordinata
			coordinata = coordinata * (Math.pow(10, potenza));
			return coordinata;
		} else
			return 0.0;
	}

	/**
	 * converte la coordinata latitudine in formato UTM in formato decimale la
	 * coordinata testuale deve essere del tipo 0.2221223E06
	 * 
	 * @param coordinata
	 *            in formato UTM, Zona
	 * @return coordinata in formato decimale
	 */
	public double utm2Lat(Double utmLat, Double utmLon, String zona) {
		CoordinateConversion converter = new CoordinateConversion();
		String utmLatStr = Double.toString(utmLat);
		String utmLonStr = Double.toString(utmLon);
		String utmCoordinates = zona + utmLatStr + " " + utmLonStr;
		double[] latLon = converter.utm2LatLon(utmCoordinates);
		double lat = latLon[0];
		return lat;
	}

	/**
	 * converte la coordinata longitudine in formato UTM in formato decimale la
	 * coordinata testuale deve essere del tipo 0.2221223E06
	 * 
	 * @param coordinata
	 *            in formato UTM, Zona
	 * @return coordinata in formato decimale
	 */
	public double utm2Lon(Double utmLat, Double utmLon, String zona) {
		CoordinateConversion converter = new CoordinateConversion();
		String utmLatStr = Double.toString(utmLat);
		String utmLonStr = Double.toString(utmLon);
		String utmCoordinates = zona + utmLatStr + " " + utmLonStr;
		double[] latLon = converter.utm2LatLon(utmCoordinates);
		double longitudine = latLon[1];
		return longitudine;
	}

	/**
	 * Crea la stringa relativa al vertice in ingresso secondo quanto stabilito
	 * nel documento
	 * 
	 * @param URI
	 *            poligono, URI punto , Uri ontologia, e numero progressivo del
	 *            punto nel poligono
	 * @return Stringa URIVertice
	 * @see https://docs.google.com/a/okkam.it/document/d/1qH9-5
	 *      oQ16tww4mySbDgVgDVL3012CzBmCoeUurruyW8/edit
	 */
	public String creaURIVertice(String URIpoligono, String URIpunto,
			String URIontologia, String ordine) {
		String URIvertice = URIpoligono;
		int indice = URIontologia.length();
		String subURI = URIpunto.substring(indice);
		URIvertice = URIvertice + subURI + "/w/" + ordine;
		URIvertice = cleanURI(URIvertice);
		return URIvertice;
	}

	public String creaURIVerticeChanges(String URIpoligono, String URIpunto,
			String URIontologia, String ordine) {

		String URIvertice = URIpoligono;
		int indice = URIontologia.length();
		String subURI = URIpunto.substring(indice);
		URIvertice = URIvertice + subURI + "/w/" + ordine;
	
		URIvertice = cleanURI(URIvertice);

		return URIvertice;

	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */
	public String leggiProgressivo(String lettura) {

		StringTokenizer st = new StringTokenizer(lettura, " ");

		String progressivo = new String();

		progressivo = st.nextToken();

		return progressivo;

	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */

	public Vertice leggiVertice(String lettura, int indice) {

		Vertice vertex = new Vertice();

		Punto puntoLetto = new Punto();

		Utility ut = new Utility();

		StringTokenizer st = new StringTokenizer(lettura, " ");

		while (st.hasMoreTokens()) {

			String coordX = st.nextToken();

			String coordY = st.nextToken();

			double cX = ut.convertiTestoToNumero(coordX);

			double cY = ut.convertiTestoToNumero(coordY);

			double lat = ut.utm2Lat(cX, cY, "32 T "/* NORD_ITALIA */);

			double lon = ut.utm2Lon(cX, cY, "32 T "/* NORD_ITALIA */);

			puntoLetto.setX(lat);

			puntoLetto.setY(lon);

			vertex.setVertice(puntoLetto);

			vertex.setCardinalita(indice);

		}

		return vertex;

	}
	/** Metodo che partendo dalla riga letta dal file restituisce il Punto
	 * 
	 * 
	 * @param
	 * @return
	 */

	public Punto leggiPunto(String lettura) {

		Punto puntoLetto = new Punto();
		Utility ut = new Utility();
		StringTokenizer st = new StringTokenizer(lettura, " ");
		while (st.hasMoreTokens()) {
			String coordX = st.nextToken();
			String coordY = st.nextToken();
			double cX = ut.convertiTestoToNumero(coordX);
			double cY = ut.convertiTestoToNumero(coordY);
			double lat = ut.utm2Lat(cX, cY, "32 T "/* NORD_ITALIA */);
			double lon = ut.utm2Lon(cX, cY, "32 T "/* NORD_ITALIA */);
			puntoLetto.setX(lat);
			puntoLetto.setY(lon);
		}
		return puntoLetto;

	}
	/**
	 * 
	 * 
	 * @param
	 * @return
	 */

	public Vertice leggiVerticeChangesE02(String lettura, int indice) {

		Vertice vertex = new Vertice();
		Punto puntoLetto = new Punto();
		Utility ut = new Utility();
		StringTokenizer st = new StringTokenizer(lettura, " ");
		while (st.hasMoreTokens()) {
			String coordX = st.nextToken();
			String coordY = st.nextToken();
			double lat = ut.convertiTestoToNumero(coordX);
			double lon = ut.convertiTestoToNumero(coordY);
			puntoLetto.setX(lat);
			puntoLetto.setY(lon);
			vertex.setVertice(puntoLetto);
			vertex.setCardinalita(indice);
		}
		return vertex;
	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */

	public Vertice leggiVerticeChangesWGS84(String lettura, int indice) {

		Vertice vertex = new Vertice();
		Punto puntoLetto = new Punto();
		StringTokenizer st = new StringTokenizer(lettura, " ");
		while (st.hasMoreTokens()) {
			String coordX = st.nextToken();
			String coordY = st.nextToken();
			double lat = Double.parseDouble(coordX);
			double lon = Double.parseDouble(coordY);
			puntoLetto.setX(lat);
			puntoLetto.setY(lon);
			vertex.setVertice(puntoLetto);
			vertex.setCardinalita(indice);
			}
		return vertex;
	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */

	public Punto leggiCentro(String lettura) {

		Punto puntoLetto = null;

		Utility ut = new Utility();

		StringTokenizer st = new StringTokenizer(lettura, " ");

		int numTokens = st.countTokens();

		if (numTokens == 3) {

			while (st.hasMoreTokens()) {

				// leggi centro

				String numeroProgressivo = st.nextToken(); // salto una riga per

				// saltare il

				// progressivo

				String coordX = st.nextToken();

				String coordY = st.nextToken();

				double cX = ut.convertiTestoToNumero(coordX);

				double cY = ut.convertiTestoToNumero(coordY);

				double lat = ut.utm2Lat(cX, cY, "32 T "/* NORD_ITALIA */);

				double lon = ut.utm2Lon(cX, cY, "32 T "/* NORD_ITALIA */);

				puntoLetto = new Punto();

				puntoLetto.setX(lat);

				puntoLetto.setY(lon);

				// puntoLetto.setX(puntoLetto.getX());

				// puntoLetto.setY(puntoLetto.getY());

			}

		} else {

			System.out.println("Errore in " + lettura);

		}

		return puntoLetto;

	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */
	public String creaURIPunto(String ontologia, Punto punto) {

		String URIpunto = null;

		ontologia = ontologia + "/punto";

		URIpunto = ontologia + "/lat/" + getParteIntera(punto.getX()) + "/"
				+ getParteFrazionaria(punto.getX()) + "/lon/"
				+ getParteIntera(punto.getY()) + "/"
				+ getParteFrazionaria(punto.getY()) + "/wgs84";
		URIpunto = cleanURI(URIpunto);
		return URIpunto;

	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */
	public String getParteIntera(double numero) {

		String intera = null;

		String numeroStr = Double.toString(numero);

		int punto = trovaPosizionePunto(numeroStr);

		intera = numeroStr.substring(0, punto);

		return intera;

	}

	/**
	 * Prende la parte frazionaria del numero in ingresso
	 * 
	 * @param numero
	 *            di tipo double
	 * @return stringa con parte frazionaria
	 */
	public String getParteFrazionaria(double numero) {

		String fraz = null;

		String numeroStr = Double.toString(numero);

		int punto = trovaPosizionePunto(numeroStr);

		fraz = numeroStr.substring(punto + 1);

		return fraz;

	}

	/**
	 * trova l-indice in cui e' presente il punto, separando di fatto la parte
	 * intera da quella da quella frazionaria
	 * 
	 * @param Stringa
	 *            indagata
	 * @return intero con posizione punto
	 */
	public int trovaPosizionePunto(String stringaIndagata) {

		int i = 0;

		for (int j = 0; j < stringaIndagata.length(); j++) {

			if (stringaIndagata.charAt(j) == '.') {

				i = j;

			}

		}

		return i;
	}

	public boolean trovaPunto(String stringaIndagata) {
		boolean isPunto = false;
		int i = 0;

		for (int j = 0; j < stringaIndagata.length(); j++) {

			if (stringaIndagata.charAt(j) == '.') {

				isPunto = true;

			}

		}

		return isPunto;
	}

	public int trovaPosizioneSlash(String stringaIndagata) {

		int i = 0;

		for (int j = 0; j < stringaIndagata.length(); j++) {

			if (stringaIndagata.charAt(j) == '/') {

				i = j;
			}
		}
		return i;
	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */
	public String creaURIPoligono(String ontologia,
			ParticellaCatastale particella) {

		String URIpoligono = null;

		String numEDen = getNumEDen(particella);

		ontologia = ontologia + "/poligono";

		if (particella.getEdificialeFondiaria().equalsIgnoreCase("edificiale")) {

			// text here caso EDIFICIALE

			URIpoligono = ontologia + "/" + "pe" + "/" + numEDen;
			
			

		}

		else {

			// text here caso Fondiaria

			URIpoligono = ontologia + "/" + "pf" + "/" + numEDen;

		}
		if (particella.getTipologia().equals("C")) {
			URIpoligono = URIpoligono + "C/";
		}
		
		if (particella.getNumeroPertinenza() != null) {
			URIpoligono = URIpoligono + "/prg"
					+ particella.getNumeroPertinenza();
		}
		URIpoligono = cleanURI(URIpoligono);
		return URIpoligono;

	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */
	public String getNumEDen(ParticellaCatastale particella) {

		String numEDen = particella.getNumero();

		if (particella.getDenominatore() != null) {

			numEDen = numEDen + "/" + particella.getDenominatore();

		}

		return numEDen;

	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */
	public String creaURIParticella(String ontologia, String numEDen,
			ParticellaCatastale particella) {
		String URIParticella = null;

		if (particella.getEdificialeFondiaria().equalsIgnoreCase("edificiale")) {
			// text here caso EDIFICIALE
			URIParticella = ontologia + "/" + "pe" + "/" + numEDen;
		} else {
			// text here caso Fondiaria
			URIParticella = ontologia + "/" + "pf" + "/" + numEDen;
		}
		if (particella.getTipologia().equals("C")) {
			URIParticella = URIParticella + "/C/";
		}
		if (particella.getNumeroPertinenza() != null) {
			URIParticella = URIParticella + "prg"
					+ particella.getNumeroPertinenza();
		}

		
		return cleanURI(URIParticella);
	}

	public String cleanURI(String uri) {
	
		if (uri.lastIndexOf("//") > 6) {
			String[] parts = uri.split("//");
			String newUri = parts[0]+"//"+parts[1]+
					 "/" + parts[2];
			uri = newUri;
		}
		return uri;
	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */
	public ArrayList<Particella> leggiParticelle(
			ArrayList<String> contenutoFilePoligoni) {
		ArrayList<Particella> listaParticelleLettura = new ArrayList<Particella>();
		boolean flagErrore = false;
		Poligono poligonoLetto = null;
		Set<Vertice> puntiPoligono = null;
		Punto centroParticella = new Punto();
		String progressivoParticella = new String();
		int indiceOrdine = 0;

		for (String rigaLetta : contenutoFilePoligoni) {
			
			// gestione errore
			if (rigaLetta.startsWith("-")) {
				// caso errore
				flagErrore = true;
			} else {
				if (rigaLetta.equals("END")) {

					{
						if (flagErrore == false) {
							// fine poligono
							poligonoLetto.setPoligono(puntiPoligono); // carico
																		// i
																		// punti
																		// del
																		// poligono

							// creo la particella e la popolo
							Particella particellaLetta = new Particella();
							particellaLetta.setPoligono(poligonoLetto);
							particellaLetta.setCentro(centroParticella);
							particellaLetta
									.setProgressivo(progressivoParticella);

							// carico la particella sulla lista delle particelle
							// lette
							listaParticelleLettura.add(particellaLetta);

							// mi preparo a leggere un'altra particella
							indiceOrdine = 0;
						} else {
							flagErrore = false;
						}
					}
				} else {
					if (flagErrore == false) {
						if (!rigaLetta.startsWith("0")) {
							// caso errore con -99999

							// caso centroide
							poligonoLetto = new Poligono();
							puntiPoligono = new HashSet<Vertice>();
							centroParticella = leggiCentro(rigaLetta);
							progressivoParticella = leggiProgressivo(rigaLetta);

						} else {
							// caso vertice
							Vertice vertice = new Vertice();
							Punto puntoLetto = leggiPunto(rigaLetta);
							Boolean check = false;
							Iterator<Vertice> it = puntiPoligono.iterator();
							while (it.hasNext()){
								Vertice verticeInserito = it.next();
								Punto punto= verticeInserito.getVertice();
								if ((punto.getX()==puntoLetto.getX())&&(punto.getY()==puntoLetto.getY())){
									//System.out.println("doppione trovato");
									check = true;
								}
							}
							if (check == false){
							indiceOrdine++;
							vertice = leggiVertice(rigaLetta, indiceOrdine);
							puntiPoligono.add(vertice);}
						}
					}
				}
			}
		}

		return listaParticelleLettura;
	}

	/**
	 * 
	 * 
	 * @param
	 * @return
	 */
	public ArrayList<AttributiParticella> leggiAttributi(
			ArrayList<String> contenutoFileAttributi) {
		ArrayList<AttributiParticella> listaAttributi = new ArrayList<AttributiParticella>();
		for (String rigaLetta : contenutoFileAttributi) {
			//
			AttributiParticella attributiParticellaLetta = new AttributiParticella();
			String progressivo, principalePertinenza, numeroDenominatore;

			if (!(rigaLetta.startsWith("n"))) {
				String[] partiRigaLetta = rigaLetta.split(" "); // da migliorare
																// (controllo se
																// ci sono
																// errori)

				// set progressivo
				progressivo = partiRigaLetta[0];

				attributiParticellaLetta.setProgressivo(progressivo);

				// set pertinenza o principale
				principalePertinenza = partiRigaLetta[1];

				if (principalePertinenza.equals("C")) {
					attributiParticellaLetta
							.setPrincipalePertinenza("pertinenza");
				} else {
					attributiParticellaLetta
							.setPrincipalePertinenza("principale");
				}

				// set numero denominatore e punto
				numeroDenominatore = partiRigaLetta[2];

				// controllo se c'e' il punto
				if (numeroDenominatore.startsWith(".")) {
					attributiParticellaLetta.setPresenzaPunto(true);
					numeroDenominatore = numeroDenominatore.substring(1);
				} else {
					attributiParticellaLetta.setPresenzaPunto(false);
				}
				// controllo se c'e' la /
				if (numeroDenominatore.contains("/")) {
					String stringaDaDividere = numeroDenominatore;
					String delims = "/";
					String[] tokens = stringaDaDividere.split(delims);
					attributiParticellaLetta.setNumero(tokens[0]);
					attributiParticellaLetta.setDenominatore(tokens[1]);
				} else {
					attributiParticellaLetta.setNumero(numeroDenominatore);
				}
				// carico gli attributi letti sulla lista
				listaAttributi.add(attributiParticellaLetta);
			}

		}
		return listaAttributi;
	}

	/*
	 * public Model fillModel (Resource particellaRisorsa , Resource
	 * comuneRisorsa, ParticellaCatastale particella, String
	 * ontologiaFolgariaCatasto){
	 * 
	 * String particellaURI = null; String poligonoURI = null; String puntoURI =
	 * null; String verticeURI = null; Model model =
	 * ModelFactory.createDefaultModel(); model.setNsPrefix("pc",
	 * "http://www.okkam.it/ont/particella_catastale.owl#"); // set del prefisso
	 * 
	 * Costanti.setUriComuni(); String comuneURI =
	 * Costanti.uriComuni.get(particella.getComune());
	 * particellaRisorsa.addProperty(S.haComuneCatastale, comuneRisorsa);
	 * particellaRisorsa.addProperty(S.haNumero, particella.getNumero());
	 * 
	 * if (particella.getDenominatore()!=null){
	 * particellaRisorsa.addProperty(S.haDenominatore,
	 * particella.getDenominatore());} if
	 * (particella.getEdificialeFondiaria().equalsIgnoreCase("edificiale")){
	 * //text here caso EDIFICIALE particellaRisorsa.addProperty(RDF.type,
	 * S.ParticellaEdificiale); } else{ //text here caso Fondiaria
	 * particellaRisorsa.addProperty(RDF.type, S.ParticellaFondiaria); }
	 * 
	 * Poligono poligonoLetto = particella.getPoligono();
	 * 
	 * poligonoURI = creaURIPoligono(ontologiaFolgariaCatasto, particella);
	 * Resource poligonoRisorsa = model.createResource(poligonoURI);
	 * particellaRisorsa.addProperty(S.haPoligono, poligonoRisorsa);
	 * List<Vertice> listaVertici = poligonoLetto.getPoligono();
	 * 
	 * }
	 */
	public ArrayList<ParticellaCatastale> creaListaParticelleCatastaliEdificialePrincipale(
			ArrayList<Particella> listaParticelleLette,
			ArrayList<AttributiParticella> listaAttributiLetti, String comune,
			String codiceComune) {
		ArrayList<ParticellaCatastale> listaPC = new ArrayList<ParticellaCatastale>();
		for (int i = 0; i < listaAttributiLetti.size(); i++) {
			Particella particellaIndagata = new Particella();
			AttributiParticella attributiParticellaIndagata = new AttributiParticella();
			particellaIndagata = listaParticelleLette.get(i);
			attributiParticellaIndagata = listaAttributiLetti.get(i);

			if (particellaIndagata.getProgressivo().equals(
					attributiParticellaIndagata.getProgressivo())) {
				ParticellaCatastale particellaCatastaleLetta = new ParticellaCatastale();
				if (attributiParticellaIndagata.isPresenzaPunto()) {
					if (attributiParticellaIndagata.getPrincipalePertinenza()
							.equals("principale")) {
						// set codice comune
						particellaCatastaleLetta.setCodiceComune(codiceComune);
						// set numero
						particellaCatastaleLetta
								.setNumero(attributiParticellaIndagata
										.getNumero());
						// set denominatore
						particellaCatastaleLetta
								.setDenominatore(attributiParticellaIndagata
										.getDenominatore());
						// set comune
						particellaCatastaleLetta.setComune(comune);
						// set poligono
						particellaCatastaleLetta.setPoligono(particellaIndagata
								.getPoligono());
						// set centro
						particellaCatastaleLetta.setCentro(particellaIndagata
								.getCentro());
						// set extent min
						ExtentParticelle extent = new ExtentParticelle();
						Double[] exMin = extent.getExtentMin(particellaIndagata
								.getPoligono());
						particellaCatastaleLetta.setExtentMin(exMin);
						// set extent max
						Double[] exMax = extent.getExtentMax(particellaIndagata
								.getPoligono());
						particellaCatastaleLetta.setExtentMax(exMax);
						// set edificiale
						particellaCatastaleLetta
								.setEdificialeFondiaria("Edificiale");
						// set tipologia
						particellaCatastaleLetta.setTipologia("P");
						listaPC.add(particellaCatastaleLetta);
					}
				}
			}
		}
		return listaPC;
	}

	public ArrayList<ParticellaCatastale> creaListaParticelleCatastaliFondiariaPrincipale(
			ArrayList<Particella> listaParticelleLette,
			ArrayList<AttributiParticella> listaAttributiLetti, String comune,
			String codiceComune) {

		ArrayList<ParticellaCatastale> listaPC = new ArrayList<ParticellaCatastale>();

		for (int i = 0; i < listaAttributiLetti.size(); i++) {
			Particella particellaIndagata = new Particella();
			AttributiParticella attributiParticellaIndagata = new AttributiParticella();
			particellaIndagata = listaParticelleLette.get(i);
			attributiParticellaIndagata = listaAttributiLetti.get(i);

			if (particellaIndagata.getProgressivo().equals(
					attributiParticellaIndagata.getProgressivo())) {
				ParticellaCatastale particellaCatastaleLetta = new ParticellaCatastale();
				if (attributiParticellaIndagata.isPresenzaPunto() == false) {
					if (attributiParticellaIndagata.getPrincipalePertinenza()
							.equals("principale")) {
						// set codice comune
						particellaCatastaleLetta.setCodiceComune(codiceComune);
						// set numero
						particellaCatastaleLetta
								.setNumero(attributiParticellaIndagata
										.getNumero());
						// set denominatore
						particellaCatastaleLetta
								.setDenominatore(attributiParticellaIndagata
										.getDenominatore());
						// set comune
						particellaCatastaleLetta.setComune(comune);
						// set poligono
						particellaCatastaleLetta.setPoligono(particellaIndagata
								.getPoligono());
						// set centro
						particellaCatastaleLetta.setCentro(particellaIndagata
								.getCentro());
						// set extent min
						ExtentParticelle extent = new ExtentParticelle();
						Double[] exMin = extent.getExtentMin(particellaIndagata
								.getPoligono());
						particellaCatastaleLetta.setExtentMin(exMin);
						// set extent max
						Double[] exMax = extent.getExtentMax(particellaIndagata
								.getPoligono());
						particellaCatastaleLetta.setExtentMax(exMax);
						// set edificiale
						if (attributiParticellaIndagata.isPresenzaPunto()) {
							particellaCatastaleLetta
									.setEdificialeFondiaria("Edificiale");
						} else {
							particellaCatastaleLetta
									.setEdificialeFondiaria("Fondiaria");
						}
						// set tipologia
						particellaCatastaleLetta.setTipologia("P");
						//

						listaPC.add(particellaCatastaleLetta);
					}
				}
			}
		}
		return listaPC;
	}

	public ArrayList<ParticellaCatastale> creaListaParticelleCatastaliEdificialePertinenze(
			ArrayList<Particella> listaParticelleLette,
			ArrayList<AttributiParticella> listaAttributiLetti, String comune,
			String codiceComune) {
		ArrayList<ParticellaCatastale> listaPC = new ArrayList<ParticellaCatastale>();

		// creazione lista attributi
		UtilityPertinenze utPe = new UtilityPertinenze();
		HashMap<String, String> map = utPe.createHashMap(listaAttributiLetti);
		HashMap<String, String> mapProg = utPe.appendProgressivo(map);
		ArrayList<AttributiParticella> lista = utPe.conversionHMToList(mapProg);

		for (int j = 0; j < listaParticelleLette.size(); j++) {
			Particella particellaIndagata = new Particella();
			particellaIndagata = listaParticelleLette.get(j);
			for (int i = 0; i < lista.size(); i++) {
				AttributiParticella attributiParticellaIndagata = new AttributiParticella();
				attributiParticellaIndagata = lista.get(i);

				if (particellaIndagata.getProgressivo().equals(
						attributiParticellaIndagata.getProgressivo())) {

					ParticellaCatastale particellaCatastaleLetta = new ParticellaCatastale();
					if (attributiParticellaIndagata.isPresenzaPunto() == true) {
						if (attributiParticellaIndagata
								.getPrincipalePertinenza().equals("pertinenza")) {
							// set codice comune
							particellaCatastaleLetta
									.setCodiceComune(codiceComune);
							// set numero
							particellaCatastaleLetta
									.setNumero(attributiParticellaIndagata
											.getNumero());
							// set denominatore
							particellaCatastaleLetta
									.setDenominatore(attributiParticellaIndagata
											.getDenominatore());
							// set comune
							particellaCatastaleLetta.setComune(comune);
							// set poligono
							particellaCatastaleLetta
									.setPoligono(particellaIndagata
											.getPoligono());
							// set centro
							particellaCatastaleLetta
									.setCentro(particellaIndagata.getCentro());
							// set extent min
							ExtentParticelle extent = new ExtentParticelle();
							Double[] exMin = extent
									.getExtentMin(particellaIndagata
											.getPoligono());
							particellaCatastaleLetta.setExtentMin(exMin);
							// set extent max
							Double[] exMax = extent
									.getExtentMax(particellaIndagata
											.getPoligono());
							particellaCatastaleLetta.setExtentMax(exMax);
							// set edificiale
							if (attributiParticellaIndagata.isPresenzaPunto()) {
								particellaCatastaleLetta
										.setEdificialeFondiaria("Edificiale");
							} else {
								particellaCatastaleLetta
										.setEdificialeFondiaria("Fondiaria");
							}
							//
							// set numero pertinenza
							if (attributiParticellaIndagata
									.getNumeroPertinenza() != null) {

								particellaCatastaleLetta
										.setNumeroPertinenza(attributiParticellaIndagata
												.getNumeroPertinenza());
							}
							// set tipologia
							particellaCatastaleLetta.setTipologia("C");

							listaPC.add(particellaCatastaleLetta);
						}
					}
				}
			}
		}
		return listaPC;
	}

	public ArrayList<ParticellaCatastale> creaListaParticelleCatastaliFondiariaPertinenze(
			ArrayList<Particella> listaParticelleLette,
			ArrayList<AttributiParticella> listaAttributiLetti, String comune,
			String codiceComune) {

		ArrayList<ParticellaCatastale> listaPC = new ArrayList<ParticellaCatastale>();

		// creazione lista attributi
		UtilityPertinenze utPe = new UtilityPertinenze();
		HashMap<String, String> map = utPe.createHashMap(listaAttributiLetti);
		HashMap<String, String> mapProg = utPe.appendProgressivo(map);
		ArrayList<AttributiParticella> lista = utPe.conversionHMToList(mapProg);

		for (int j = 0; j < listaParticelleLette.size(); j++) {
			Particella particellaIndagata = new Particella();
			particellaIndagata = listaParticelleLette.get(j);
			for (int i = 0; i < lista.size(); i++) {
				AttributiParticella attributiParticellaIndagata = new AttributiParticella();
				attributiParticellaIndagata = lista.get(i);

				if (particellaIndagata.getProgressivo().equals(
						attributiParticellaIndagata.getProgressivo())) {

					ParticellaCatastale particellaCatastaleLetta = new ParticellaCatastale();
					if (attributiParticellaIndagata.isPresenzaPunto() == false) {
						if (attributiParticellaIndagata
								.getPrincipalePertinenza().equals("pertinenza")) {
							// set codice comune
							particellaCatastaleLetta
									.setCodiceComune(codiceComune);
							// set numero
							particellaCatastaleLetta
									.setNumero(attributiParticellaIndagata
											.getNumero());
							// set denominatore
							particellaCatastaleLetta
									.setDenominatore(attributiParticellaIndagata
											.getDenominatore());
							// set comune
							particellaCatastaleLetta.setComune(comune);
							// set poligono
							particellaCatastaleLetta
									.setPoligono(particellaIndagata
											.getPoligono());
							// set centro
							particellaCatastaleLetta
									.setCentro(particellaIndagata.getCentro());
							// set extent min
							ExtentParticelle extent = new ExtentParticelle();
							Double[] exMin = extent
									.getExtentMin(particellaIndagata
											.getPoligono());
							particellaCatastaleLetta.setExtentMin(exMin);
							// set extent max
							Double[] exMax = extent
									.getExtentMax(particellaIndagata
											.getPoligono());
							particellaCatastaleLetta.setExtentMax(exMax);
							// set edificiale
							if (attributiParticellaIndagata.isPresenzaPunto()) {
								particellaCatastaleLetta
										.setEdificialeFondiaria("Edificiale");
							} else {
								particellaCatastaleLetta
										.setEdificialeFondiaria("Fondiaria");
							}
							//
							// set numero pertinenza
							if (attributiParticellaIndagata
									.getNumeroPertinenza() != null) {

								particellaCatastaleLetta
										.setNumeroPertinenza(attributiParticellaIndagata
												.getNumeroPertinenza());
							}
							// set tipologia
							particellaCatastaleLetta.setTipologia("S");

							listaPC.add(particellaCatastaleLetta);
						}
					}
				}
			}
		}
		return listaPC;
	}

	public void printExecutionTime(long StartTime,
			List<ParticellaCatastale> lista) {
		DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
		Date date = new Date();
		final long endTime = System.currentTimeMillis();
		long exTime = endTime - StartTime;
		int sec = (int) (exTime / 1000);
		int ms = (int) exTime - (sec * 1000);

		System.out.println("[" + dateFormat.format(date)
				+ "] Tempo di esecuzione: " + sec + " sec e " + ms + " ms");
		System.out.println("[" + dateFormat.format(date)
				+ "] Sono state importate " + lista.size()
				+ " particelle catastali");

	}

	public void printExecutionTimeComuni(long StartTime,
			List<ConfineComune> lista) {
		DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
		Date date = new Date();
		final long endTime = System.currentTimeMillis();
		long exTime = endTime - StartTime;
		int sec = (int) (exTime / 1000);
		int ms = (int) exTime - (sec * 1000);
		System.out.println("[" + dateFormat.format(date)
				+ "] Tempo di esecuzione: " + sec + " sec e " + ms + " ms");
		System.out.println("[" + dateFormat.format(date)
				+ "] Sono stati importati " + lista.size() + " comuni");

	}

	/**
	 * restituisce la data e l'ora
	 * 
	 * @param
	 * @return stringa
	 */

	public String getData() {
		DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
		Date date = new Date();
		String out = "[" + dateFormat.format(date) + "] ";
		return out;
	}

	public void printExecutionTimeChanges(long StartTime,
			List<EventoCambiamento> lista) {
		DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
		Date date = new Date();
		final long endTime = System.currentTimeMillis();
		long exTime = endTime - StartTime;
		int sec = (int) (exTime / 1000);
		int ms = (int) exTime - (sec * 1000);
		System.out.println("[" + dateFormat.format(date)
				+ "] Tempo di esecuzione: " + sec + " sec e " + ms + " ms");
		System.out.println("[" + dateFormat.format(date)
				+ "] Sono stati importati " + lista.size() + " cambiamenti");

	}

	public long printInitialTimeSetTime(String path) {
		DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
		Date date = new Date();
		File fileOut = new File(path);
		System.out.println("[" + dateFormat.format(date)
				+ "] Elaborazione file: " + fileOut.getName() + " in corso.");
		final long startTime = System.currentTimeMillis();
		return startTime;
	}

	public int findId(String rigaLetta) {
		// TODO Auto-generated method stub
		String idString = rigaLetta.substring(3);
		int id = Integer.parseInt(idString);
		return id;
	}

}